home *** CD-ROM | disk | FTP | other *** search
/ Developer CD Series 1997 January: Mac OS SDK / Dev.CD Jan 97 SDK1.toast / Development Kits (Disc 1) / AppleScript / Development Tools / Sample Code / 7Edit 3.1 / Sources / SVAETextUtils.c < prev    next >
Encoding:
Text File  |  1995-11-20  |  18.5 KB  |  797 lines  |  [TEXT/CWIE]
  1. // SVAETextUtils.c
  2. //
  3. // 7Edit 3.1d1. Original version by Jon Lansdell and Nigel Humphreys.
  4. // 3.1 updates by Greg Sutton.
  5. // ©Apple Computer Inc 1995, all rights reserved.
  6.  
  7. #include "SVAETextUtils.h"
  8.  
  9. #include "SVEditAEUtils.h"
  10. #include "SVEditWindow.h"        // for DPtrFromWindowPtr()
  11. #include "SVAERecording.h"
  12.  
  13.  
  14. #include <AEPackObject.h>
  15.  
  16.  
  17.  
  18. // ----------------------------------------------------------------------------------
  19. //    Name:    PutStyledTextFromDescIntoTEHandle
  20. //    Purpose: Takes the text in an AEDesc containing typeIntlText and puts it in
  21. //             a styled text edit record at the current insertion point.
  22. //                     Looks for typeIntlText, typeStyledText, typeChar in that order.
  23. // ----------------------------------------------------------------------------------
  24.  
  25. OSErr    PutStyledTextFromDescIntoTEHandle(const AEDesc *sourceTextDesc, TEHandle theHTE)
  26. {
  27.     AEDesc styledTextDesc;
  28.     AEDesc textStyleDesc;
  29.     AEDesc rawTextDesc;
  30.     OSErr  myErr;
  31.     OSErr  ignoreErr;
  32.     
  33.     styledTextDesc.dataHandle = nil;
  34.     textStyleDesc.dataHandle  = nil;
  35.     rawTextDesc.dataHandle    = nil;
  36.     
  37.     //    Coerce to an AERecord and then extract the parts of the
  38.     //    styled text - works for typeIntlText, typeStyledText
  39.  
  40.     myErr = AECoerceDesc(sourceTextDesc, typeAERecord, &styledTextDesc);
  41.     
  42.     if (noErr == myErr)
  43.     {        
  44.         myErr = AEGetKeyDesc(&styledTextDesc,
  45.                                                  keyAEText,
  46.                                                  typeChar,
  47.                                                  &rawTextDesc);
  48.                                                  
  49.         myErr = AEGetKeyDesc(&styledTextDesc,
  50.                                                  keyAEStyles,
  51.                                                  typeScrapStyles,
  52.                                                  &textStyleDesc);
  53.     }
  54.     else
  55.     {
  56.         myErr = AECoerceDesc(sourceTextDesc, typeChar, &rawTextDesc);
  57.         
  58.         textStyleDesc.dataHandle = NULL; // so that TEStylInsert acts like TEInsert                
  59.     }
  60.             
  61.     HLock((Handle)rawTextDesc.dataHandle);
  62.     
  63.     TEDelete(theHTE);                    // Insert over current selection
  64.     TEStylInsert((const void *) (*rawTextDesc.dataHandle),
  65.                                          GetHandleSize(rawTextDesc.dataHandle),
  66.                                              (StScrpHandle) textStyleDesc.dataHandle,
  67.                                                  theHTE);
  68.                              
  69.     HUnlock((Handle)rawTextDesc.dataHandle);
  70.     
  71.     if (textStyleDesc.dataHandle)
  72.         ignoreErr = AEDisposeDesc(&textStyleDesc);
  73.     
  74.     if (rawTextDesc.dataHandle)
  75.         ignoreErr = AEDisposeDesc(&rawTextDesc);
  76.     
  77.     if (styledTextDesc.dataHandle)
  78.         ignoreErr = AEDisposeDesc(&styledTextDesc);
  79.         
  80.     return(myErr);
  81. }
  82.  
  83.  
  84. TEHandle    TEHandleFromWindow(WindowPtr theWindow)
  85. {
  86.     DPtr        docPtr;
  87.     TEHandle    result = NULL;
  88.     
  89.     if (! theWindow)
  90.         return(NULL);
  91.     
  92.     docPtr = DPtrFromWindowPtr(theWindow);
  93.     
  94.     if (docPtr)
  95.         result = docPtr->theText;
  96.         
  97.     return(result);
  98. }
  99.  
  100. TEHandle    TEHandleFromTextToken(TextToken* aToken)
  101. {
  102.     if (! aToken)
  103.         return(NULL);
  104.         
  105.     return(TEHandleFromWindow(aToken->tokenWindow));
  106. }
  107.  
  108.  
  109. OSErr    GetInsertDescFromInsertHere(AEDesc* insertHereDesc, AEDesc* insertDesc, DescType* insertType)
  110. {
  111.     AEDesc        insertRec = {typeNull, NULL},
  112.                 objectSpec = {typeNull, NULL};
  113.     DescType    returnedType;
  114.     Size        actualSize;
  115.     OSErr        err;
  116.  
  117.      switch (insertHereDesc->descriptorType)
  118.      {
  119.          case typeInsertionLoc:
  120.              err = AECoerceDesc(insertHereDesc, typeAERecord, &insertRec);
  121.              if (noErr != err) goto done;
  122.              
  123.              err = AEGetKeyPtr(&insertRec, keyAEPosition, typeEnumeration, &returnedType,
  124.                                          (Ptr)insertType, sizeof(insertType), &actualSize);
  125.              if (noErr != err) goto done;
  126.  
  127.             err = AEGetKeyDesc(&insertRec, keyAEObject, typeWildCard, &objectSpec);
  128.             if (objectSpec.descriptorType != typeNull)
  129.             {
  130.                 err = AEResolve(&objectSpec, kAEIDoMinimum, insertDesc);
  131.                 if (err != noErr) goto done;
  132.             }
  133.              break;
  134.      
  135.          case typeObjectSpecifier:
  136.              err = AEResolve(insertHereDesc, kAEIDoMinimum, insertDesc);
  137.              if (noErr != err) goto done;
  138.              *insertType = insertDesc->descriptorType;
  139.              break;
  140.              
  141.          case typeNull:                    // No insertion location given
  142.              *insertType = typeNull;
  143.              break;
  144.              
  145.          default:                        // Just copy the descriptor
  146.              err = AEDuplicateDesc(insertHereDesc, insertDesc);
  147.              if (noErr != err) goto done;
  148.              *insertType = insertDesc->descriptorType;
  149.      }
  150.      
  151.  done:
  152.      if (insertRec.dataHandle)
  153.          AEDisposeDesc(&insertRec);
  154.      if (objectSpec.dataHandle)
  155.          AEDisposeDesc(&objectSpec);
  156.      
  157.      return(err);
  158. }
  159.  
  160. // This routine returns an enumerated type describing the relative position
  161. // of one TextToken to another.
  162.  
  163. TokenWithinType    TokenWithinToken(TextToken* container, TextToken* token, short* numPartial)
  164. {
  165.     TokenWithinType        result;
  166.  
  167.     if (token->tokenOffset + token->tokenLength < container->tokenOffset)
  168.         result = kTokenBefore;
  169.     else if (container->tokenOffset + container->tokenLength < token->tokenOffset)
  170.         result = kTokenAfter;
  171.     else if (token->tokenOffset >= container->tokenOffset
  172.                 && token->tokenOffset + token->tokenLength <= container->tokenOffset + container->tokenLength)
  173.         result = kTokenWithin;
  174.     else if (token->tokenOffset < container->tokenOffset)
  175.     {
  176.         result = kTokenPartialBefore;
  177.         if (numPartial)
  178.             *numPartial = token->tokenOffset + token->tokenLength - container->tokenOffset;
  179.     }
  180.     else
  181.     {
  182.         result = kTokenPartialAfter;
  183.         if (numPartial)
  184.             *numPartial = container->tokenOffset + container->tokenLength - token->tokenOffset;
  185.     }
  186.     
  187.     return(result);
  188. }
  189.  
  190.  
  191. OSErr    TextTokenFromWindowToken(WindowToken* theWindowToken, TextToken* theTextToken)
  192. {
  193.     DPtr        docPtr;
  194.  
  195.     docPtr = DPtrFromWindowPtr(theWindowToken->tokenWindow);
  196.  
  197.     if (! docPtr)
  198.         return(errAENoSuchObject);
  199.             // Create our text token
  200.     theTextToken->tokenWindow = theWindowToken->tokenWindow;    
  201.     theTextToken->tokenOffset = 1;                                // Start at 1
  202.     theTextToken->tokenLength = (**docPtr->theText).teLength;    // through whole length
  203.     
  204.     return(noErr);
  205. }
  206.  
  207.  
  208. OSErr    TextTokenFromWindowDesc(AEDesc* windowDesc, TextToken* theToken)
  209. {
  210.     AEDesc            aDesc = {typeNull, NULL};
  211.     WindowToken        aWindowToken;
  212.     Size            actualSize;
  213.     OSErr            err;
  214.     
  215.     err = AECoerceDesc(windowDesc, typeMyWndw, &aDesc);
  216.     if (noErr != err) goto done;
  217.         
  218.     GetRawDataFromDescriptor(&aDesc, (Ptr)&aWindowToken,
  219.                                     sizeof(aWindowToken), &actualSize);
  220.  
  221.     err = TextTokenFromWindowToken(&aWindowToken, theToken);
  222.     
  223. done:    
  224.     if (aDesc.dataHandle)
  225.         AEDisposeDesc(&aDesc);
  226.  
  227.     return(err);
  228. }
  229.  
  230.  
  231. OSErr    TextDescFromWindowToken(WindowToken* theWindowToken, AEDesc* textDesc)
  232. {
  233.     TextToken    aToken;
  234.     OSErr        err;
  235.     
  236.     err = TextTokenFromWindowToken(theWindowToken, &aToken);
  237.     if (noErr != err) goto done;
  238.     
  239.     err = AECreateDesc(typeMyText, (Ptr)&aToken, sizeof(aToken), textDesc);
  240.  
  241. done:
  242.     return(err);
  243. }
  244.  
  245.  
  246. OSErr    TextDescFromWindowDesc(AEDesc* windowDesc, AEDesc* textDesc)
  247. {
  248.     TextToken    aToken;
  249.     OSErr        err;
  250.     
  251.     err = TextTokenFromWindowDesc(windowDesc, &aToken);
  252.     if (noErr != err) goto done;
  253.     
  254.     err = AECreateDesc(typeMyText, (Ptr)&aToken, sizeof(aToken), textDesc);
  255.  
  256. done:
  257.     return(err);
  258. }
  259.  
  260.  
  261. void MoveToNonSpace(short *start, short limit, charsHandle myChars)
  262.     // Treats space, comma, full stop, ; and : as space chars
  263. { 
  264.     short x;
  265.  
  266.     while (*start <= limit) {
  267.       x = (**myChars)[*start];
  268.         if (IsWhiteSpace(x))
  269.             (*start) +=1;
  270.         else
  271.             return;
  272.     }
  273. }
  274.     
  275. void    MoveToSpace(short *start, short limit, charsHandle myChars)
  276.     // Treats space,comma, full stop, ; and : as space chars
  277. { 
  278.     short x;
  279.     
  280.     while (*start <= limit)
  281.     {
  282.         x = (**myChars)[*start];
  283.         if (! IsWhiteSpace(x))
  284.             (*start)++;
  285.         else
  286.             return;
  287.     }
  288. }
  289.  
  290. void    MoveToEndOfParagraph(short *start, short limit, charsHandle myChars)
  291.     //    Treats CR as end of paragraph
  292. { 
  293.     short x;
  294.     
  295.     while (*start <= limit)
  296.     {
  297.         x = (**myChars)[*start];
  298.         if (! IsParagraphDelimiter(x))        // had x != CR
  299.             (*start)++;
  300.         else
  301.             return;
  302.     }
  303. }
  304.  
  305.  
  306. // This routine counts the given elementType between startAt and 
  307.  
  308. OSErr    CountTextElements(TEHandle inTextHandle, short startAt,
  309.                                 short forHowManyChars, DescType elementType, short* result)
  310. {
  311.     charsHandle    theChars;
  312.     short       limit,
  313.                 start;
  314.     OSErr        err = noErr;
  315.  
  316.     switch (elementType)
  317.     {
  318.         case cInsertionPoint:    // Always one more insertion location than characters
  319.             *result = forHowManyChars + 1;
  320.             break;
  321.             
  322.         case cChar:            // Easy
  323.             *result = forHowManyChars;
  324.             break;
  325.             
  326.         case cText:    
  327.             *result = 1;
  328.             break;
  329.         
  330.         case cWord:            // Cycle through - counting
  331.         case cParagraph:
  332.             theChars = (charsHandle)(**inTextHandle).hText;
  333.             start = startAt - 1;                    // Convert to zero based
  334.             limit = start + forHowManyChars - 1;    // when passed one based
  335.             *result    = 0;
  336.             MoveToNonSpace(&start, limit, theChars);
  337.             while (start <= limit)
  338.             {
  339.                 (*result)++;
  340.                 switch (elementType)
  341.                 {
  342.                     case cWord:
  343.                         MoveToSpace(&start, limit, theChars);
  344.                         break;
  345.                         
  346.                     case cParagraph:
  347.                         MoveToEndOfParagraph(&start, limit, theChars);
  348.                         break;
  349.                 }
  350.                 MoveToNonSpace(&start, limit, theChars);
  351.             }
  352.             break;
  353.     
  354.         default:
  355.             *result = -1;
  356.             err = errAEBadKeyForm;
  357.     }
  358.     
  359.     return(err);
  360. } // CountTextElements
  361.  
  362. OSErr    GetDescOfNthTextElement(short index, DescType elementType,
  363.                                         TextToken* containerToken, AEDesc* result)
  364. {
  365.     DPtr        docPtr;
  366.     TextToken    theToken;
  367.     short        start,
  368.                 maxChars,
  369.                 elementCount,
  370.                 limit,
  371.                 elementStart;
  372.     charsHandle    theChars;
  373.     OSErr        err;
  374.     
  375.     if (! containerToken)
  376.         return(errAEEmptyListContainer);
  377.  
  378.     docPtr = DPtrFromWindowPtr(containerToken->tokenWindow);
  379.     start = containerToken->tokenOffset - 1;    // Zero based
  380.     maxChars = containerToken->tokenLength;
  381.  
  382.     err = CountTextElements(docPtr->theText, containerToken->tokenOffset,
  383.                                         maxChars, elementType, &elementCount);
  384.     if (noErr != err) return(err);
  385.     
  386.     if (index < 0)                        // Change a negative index to positive
  387.         index = elementCount + index + 1;
  388.         
  389.     if (index > elementCount)            // Got given an index out of range
  390.         return(errAEIllegalIndex);
  391.         
  392.             // Set the window that the token relates to
  393.     theToken.tokenWindow = containerToken->tokenWindow;
  394.  
  395.     switch (elementType)
  396.     {
  397.         case cInsertionPoint:
  398.             theToken.tokenOffset = start + index - 1;
  399.             theToken.tokenLength = 0;
  400.             break;
  401.             
  402.         case cChar:        // Easy - just the start point + the index
  403.             theToken.tokenOffset = start + index;
  404.             theToken.tokenLength = 1;
  405.             break;
  406.             
  407.         case cText:    
  408.             theToken.tokenOffset = start + index;
  409.             theToken.tokenLength = maxChars;
  410.             break;
  411.             
  412.         case cWord:
  413.         case cParagraph:
  414.             theChars = (charsHandle)(**(docPtr->theText)).hText;
  415.             limit = start + maxChars - 1;
  416.             MoveToNonSpace(&start, limit, theChars);
  417.             while ((start <= limit) && (index > 0))
  418.             {
  419.                 index--;
  420.                 elementStart = start;
  421.                 switch (elementType)
  422.                 {
  423.                     case cWord:
  424.                         MoveToSpace(&start, limit, theChars);
  425.                         break;
  426.                         
  427.                     case cParagraph:
  428.                         MoveToEndOfParagraph(&start, limit, theChars);
  429.                         break;
  430.                 }
  431.                 theToken.tokenLength = start - elementStart;
  432.                 MoveToNonSpace(&start, limit, theChars);
  433.             }
  434.             theToken.tokenOffset = elementStart + 1;    // Convert to one based
  435.             break;
  436.     }
  437.  
  438.     err = AECreateDesc(typeMyText, (Ptr)&theToken, sizeof(theToken), result);
  439.  
  440.     return(err);
  441. }
  442.  
  443.  
  444. char    GetTEHChar(TEHandle aTEH, short offset)
  445. {
  446.     char    result;
  447.     
  448.     offset--;        // This is now 0 based
  449.  
  450.     if (offset < 0 || offset >= (*aTEH)->teLength)
  451.         return('\0');
  452.         
  453.     result = *(char *)((*(**aTEH).hText) + offset);
  454.     
  455.     return(result);
  456. }
  457.  
  458. Boolean        IsAtStart(TextToken* theToken)
  459. {
  460.     Boolean    result;
  461.                     // Is at start if offset is at 1
  462.     result = (theToken->tokenOffset == 1);
  463.     
  464.     return(result);
  465. }
  466.  
  467. Boolean        IsAtEnd(TextToken* theToken)
  468. {
  469.     TEHandle    aTEH;
  470.     Boolean        result;
  471.     
  472.     aTEH = TEHandleFromTextToken(theToken);
  473.                     // Does it go to the end?
  474.     result = (theToken->tokenOffset + theToken->tokenLength >= (**aTEH).teLength);
  475.     
  476.     return(result);
  477. }
  478.  
  479. Boolean        IsWhiteSpace(short aChar)
  480. {
  481.     Boolean    result;
  482.  
  483.     result = (aChar == ' ' || aChar == ',' || aChar == '.'
  484.                 || aChar == ':' || aChar == LF || aChar == CR);
  485.              
  486.     return(result);
  487. }
  488.  
  489. Boolean        IsParagraphDelimiter(short aChar)
  490. {
  491.     Boolean    result;
  492.  
  493.     result = (aChar == CR);
  494.              
  495.     return(result);
  496. }
  497.  
  498. Boolean        IsContentsToken(TextToken* theToken)
  499. {
  500.     return(IsAtStart(theToken) && IsAtEnd(theToken));
  501. }
  502.  
  503. Boolean        IsParagraphToken(TextToken* theToken, short* start, short* end)
  504. {
  505.     TEHandle    aTEH;
  506.     OSErr        err;
  507.     short        number;
  508.     Boolean        fStart,
  509.                 fEnd,
  510.                 result;
  511.     
  512. //    if (IsContentsToken(theToken))    // So we don't start and end 
  513. //        return(false);
  514.         
  515.     aTEH = TEHandleFromTextToken(theToken);
  516.         
  517.                                     // What about having CR's before end??
  518.                                     // - then it's just more paragraphs?
  519.                                     // - in STE yes - ahhh it'll be okay
  520.         
  521.     fStart = IsAtStart(theToken) || IsParagraphDelimiter(GetTEHChar(aTEH, theToken->tokenOffset - 1));
  522.     fEnd = IsAtEnd(theToken) || IsParagraphDelimiter(GetTEHChar(aTEH, theToken->tokenOffset + theToken->tokenLength));
  523.     
  524.     if (fStart && fEnd)
  525.     {
  526.         // need to do a count of the paragraphs
  527.         
  528.         err = CountTextElements(aTEH, theToken->tokenOffset,
  529.                             theToken->tokenLength, cParagraph, &number);
  530.  
  531.         // count text elements before it i.e. offset == 0 limit == theToken->tokenOffset
  532.         
  533.         if (IsAtStart(theToken))
  534.             *start = 1;
  535.         else
  536.         {                // From beginning to charracter before start of paragraph
  537.             err = CountTextElements(aTEH, 1,theToken->tokenOffset - 1, cParagraph, start);
  538.             (*start)++;
  539.         }
  540.         
  541.         *end = *start + number - 1;
  542.         
  543.         result = true;
  544.     }
  545.     else
  546.         result = false;
  547.     
  548.     return(result);
  549. }
  550.  
  551. Boolean        IsWordToken(TextToken* theToken, short* start, short* end)
  552. {
  553.     TEHandle    aTEH;
  554.     OSErr        err;
  555.     short        number;
  556.     Boolean        fStart,
  557.                 fEnd,
  558.                 result;
  559.     
  560. //    if (IsContentsToken(theToken) || IsParagraphToken(theToken, start, end))
  561. //        return(false);
  562.     
  563.     aTEH = TEHandleFromTextToken(theToken);
  564.         
  565.                                     // What about having CR's before end??
  566.                                     // - then it's just more paragraphs?
  567.                                     // - in STE yes - ahhh it'll be okay
  568.         
  569.     fStart = IsAtStart(theToken) || IsWhiteSpace(GetTEHChar(aTEH, theToken->tokenOffset - 1));
  570.     fEnd = IsAtEnd(theToken) || IsWhiteSpace(GetTEHChar(aTEH, theToken->tokenOffset + theToken->tokenLength));
  571.     
  572.     if (fStart && fEnd)
  573.     {
  574.         // need to do a count of the words
  575.         
  576.         err = CountTextElements(aTEH, theToken->tokenOffset,
  577.                             theToken->tokenLength, cWord, &number);
  578.  
  579.         // count text elements before it i.e. offset == 0 limit == theToken->tokenOffset
  580.         
  581.         if (IsAtStart(theToken))
  582.             *start = 1;
  583.         else
  584.         {                // From beginning to charracter before start of word
  585.             err = CountTextElements(aTEH, 1, theToken->tokenOffset - 1, cWord, start);
  586.             (*start)++;
  587.         }
  588.         
  589.         *end = *start + number - 1;
  590.         
  591.         result = true;
  592.     }
  593.     else
  594.         result = false;
  595.     
  596.     return(result);
  597. }
  598.  
  599.  
  600. DescType    GetTextTokenType(TextToken* theToken, short* start, short* end)
  601. {
  602.     DescType    result;
  603.     
  604.     *start = *end = -1;                    // Just set to the same value
  605.  
  606.     if (! theToken->tokenLength)
  607.     {
  608.         result = cInsertionPoint;
  609.     }
  610.     else if (IsContentsToken(theToken))
  611.     {
  612.         result = pContents;
  613.     }
  614.     else if (IsParagraphToken(theToken, start, end))
  615.     {
  616.         result = cParagraph;
  617.     }
  618.     else if (IsWordToken(theToken, start, end))
  619.     {
  620.         result = cWord;
  621.     }
  622.     else
  623.     {
  624.         result = cChar;
  625.         *start = theToken->tokenOffset;
  626.         *end = theToken->tokenOffset + theToken->tokenLength - 1;
  627.     }
  628.     
  629.     return(result);
  630. }
  631.  
  632. OSErr    MakeContentsSpecifier(TextToken* theToken, AEDesc* result)
  633. {
  634.     AEDesc        docSpec = {typeNull, NULL},
  635.                 contentsDesc = {typeNull, NULL};
  636.     DescType    propertyID;
  637.     OSErr        err;
  638.  
  639.     err = MakeDocumentObj(theToken->tokenWindow, &docSpec);
  640.     if (noErr != err) goto done;
  641.     
  642.     propertyID = pContents;
  643.     err = AECreateDesc(typeType, (Ptr)&propertyID, sizeof(DescType), &contentsDesc);
  644.     if (err != noErr) goto done;
  645.     err = CreateObjSpecifier(cProperty, &docSpec, formPropertyID, &contentsDesc, false, result);
  646.  
  647. done:
  648.     if (docSpec.dataHandle)
  649.         AEDisposeDesc(&docSpec);
  650.     if (contentsDesc.dataHandle)
  651.         AEDisposeDesc(&contentsDesc);
  652.     
  653.     return(err);
  654. }
  655.  
  656.  
  657. OSErr    MakeAbsoluteTextSpecifier(WindowPtr theWindow, DescType textType, long index, AEDesc* result)
  658. {
  659.     AEDesc        docSpec = {typeNull, NULL},
  660.                 absoluteDesc = {typeNull, NULL};
  661.     OSErr        err;
  662.     
  663.     if (theWindow)
  664.     {
  665.         err = MakeDocumentObj(theWindow, &docSpec);
  666.         if (noErr != err) goto done;
  667.     }
  668.     // else just use the NULL'ed value
  669.  
  670.     err = AECreateDesc(typeLongInteger, (Ptr)&index, sizeof(index), &absoluteDesc);
  671.     if (err != noErr) goto done;
  672.     err = CreateObjSpecifier(textType, &docSpec, formAbsolutePosition,
  673.                                                     &absoluteDesc, false, result);
  674.  
  675. done:
  676.     if (docSpec.dataHandle)
  677.         AEDisposeDesc(&docSpec);
  678.     if (absoluteDesc.dataHandle)
  679.         AEDisposeDesc(&absoluteDesc);
  680.     
  681.     return(err);
  682. }
  683.  
  684.  
  685. OSErr    MakeInsertionPointSpecifier(TextToken* theToken, AEDesc* result)
  686. {
  687.     AEDesc        relativeToSpec,
  688.                 relativeDesc;
  689.     DescType    relativeType;
  690.     OSErr        err;
  691.  
  692.     if (IsAtStart(theToken))            // Before contents (whether there are any or not)
  693.     {
  694.         relativeType = kAEPrevious;
  695.         err = MakeContentsSpecifier(theToken, &relativeToSpec);
  696.     }
  697.     else if (IsAtEnd(theToken))            // After last character
  698.     {
  699.         relativeType = kAENext;
  700.         //err = MakeContentsSpecifier(theToken, &relativeToSpec);
  701.         err = MakeAbsoluteTextSpecifier(theToken->tokenWindow, cChar, -1, &relativeToSpec);
  702.     }
  703.     else                                // Has a character it can go before
  704.     {
  705.         relativeType = kAEPrevious;
  706.         err = MakeAbsoluteTextSpecifier(theToken->tokenWindow, cChar, theToken->tokenOffset, &relativeToSpec);
  707.     }
  708.  
  709.     if (noErr != err) goto done;
  710.     
  711.       err = AECreateDesc(typeEnumerated, &relativeType, sizeof(relativeType), &relativeDesc);
  712.     if (noErr != err) goto done;
  713.     err = CreateObjSpecifier(cInsertionPoint, &relativeToSpec, formRelativePosition,
  714.                                                                    &relativeDesc, false, result);
  715.  
  716. done:
  717.     if (relativeToSpec.dataHandle)
  718.         AEDisposeDesc(&relativeToSpec);
  719.     if (relativeDesc.dataHandle)
  720.         AEDisposeDesc(&relativeDesc);
  721.  
  722.     return(err);
  723. }
  724.  
  725. OSErr    GetIndexSpecifier(TextToken* theToken, DescType textType, long index, AEDesc* result)
  726. {
  727.     OSErr    err;
  728.  
  729.     switch (textType)
  730.     {
  731.         case cInsertionPoint:
  732.             err = MakeInsertionPointSpecifier(theToken, result);
  733.             break;
  734.             
  735.         case pContents:
  736.             err = MakeContentsSpecifier(theToken, result);
  737.             break;
  738.             
  739.         case cParagraph:
  740.         case cWord:
  741.         case cChar:
  742.             err = MakeAbsoluteTextSpecifier(theToken->tokenWindow, textType, index, result);
  743.             break;
  744.         
  745.         default:
  746.             err = errAETypeError;
  747.     }
  748.     
  749.     return(err);
  750. }
  751.  
  752.  
  753. OSErr    GetTextTokenObjectSpecifier(TextToken* theToken, AEDesc* result)
  754. {
  755.     AEDesc        docSpec = {typeNull, NULL},
  756.                 startSpec = {typeNull, NULL},
  757.                 endSpec = {typeNull, NULL},
  758.                 rangeDesc = {typeNull, NULL};
  759.     DescType    textType;
  760.     short        start,
  761.                 end;
  762.     OSErr        err;
  763.     
  764.     textType = GetTextTokenType(theToken, &start, &end);
  765.     
  766.     err = GetIndexSpecifier(theToken, textType, start, &startSpec);
  767.     if (noErr != err) goto done;
  768.  
  769.     if (start != end)        // Sort out rest of range specifier
  770.     {
  771.         err = GetIndexSpecifier(theToken, textType, end, &endSpec);
  772.         if (noErr != err) goto done;
  773.         
  774.         err = CreateRangeDescriptor(&startSpec, &endSpec, false, &rangeDesc);
  775.         if (noErr != err) goto done;
  776.  
  777.         err = MakeDocumentObj(theToken->tokenWindow, &docSpec);
  778.         if (noErr != err) goto done;
  779.  
  780.         err = CreateObjSpecifier(cText, &docSpec, formRange, &rangeDesc, false, result);
  781.     }
  782.     else
  783.         err = AEDuplicateDesc(&startSpec, result);
  784.     
  785. done:
  786.     if (docSpec.dataHandle)
  787.         AEDisposeDesc(&docSpec);
  788.     if (startSpec.dataHandle)
  789.         AEDisposeDesc(&startSpec);
  790.     if (endSpec.dataHandle)
  791.         AEDisposeDesc(&endSpec);
  792.     if (rangeDesc.dataHandle)
  793.         AEDisposeDesc(&rangeDesc);
  794.  
  795.     return(err);
  796. }
  797.